package com.example.rabc.service.impl;

import com.example.rabc.entity.Permission;
import com.example.rabc.service.PermissionComponent;

import java.util.ArrayList;
import java.util.List;

/**
 * 复合权限节点 - 组合模式中的复合节点
 * 代表权限组，可以包含其他权限节点（包括叶子节点和其他复合节点）
 */
public class CompositePermission implements PermissionComponent {
    
    private Permission permission;
    private PermissionComponent parent;
    private List<PermissionComponent> children = new ArrayList<>();
    
    public CompositePermission(Permission permission) {
        this.permission = permission;
    }

    /**
     * 获取复合权限节点的ID
     * @return 权限ID
     */
    @Override
    public Long getId() {
        return permission.getId();
    }

    /**
     * 获取复合权限节点的权限代码
     * @return 权限代码
     */
    @Override
    public String getPermissionCode() {
        return permission.getPermissionCode();
    }


    /**
     * 获取复合权限节点的权限名称
     * @return 权限名称
     */
    @Override
    public String getPermissionName() {
        return permission.getPermissionName();
    }

    /**
     * 检查复合权限节点是否具有指定权限
     * @param permissionCode 权限代码
     * @return 是否具有权限
     */
    @Override
    public boolean hasPermission(String permissionCode) {
        // 首先检查自身是否具有该权限
        if (this.permission.getPermissionCode().equals(permissionCode)) {
            return true;
        }
        
        // 递归检查所有子节点是否具有该权限（权限继承机制）
        for (PermissionComponent child : children) {
            if (child.hasPermission(permissionCode)) {
                return true;
            }
        }
        
        // 向上传递给父节点检查（权限继承机制）
        if (parent != null) {
            return parent.hasPermission(permissionCode);
        }
        
        return false;
    }

    /**
     * 添加子权限节点到复合权限节点
     * @param component 权限组件
     */
    @Override
    public void add(PermissionComponent component) {
        children.add(component);
        component.setParent(this);
    }

    /**
     * 从复合权限节点移除子权限节点
     * @param component 权限组件
     */
    @Override
    public void remove(PermissionComponent component) {
        children.remove(component);
        component.setParent(null);
    }

    /**
     * 获取复合权限节点的子权限节点列表
     * @return 子权限节点列表
     */
    @Override
    public List<PermissionComponent> getChildren() {
        return new ArrayList<>(children);
    }

    /**
     * 获取复合权限节点的父权限节点
     * @return 父权限节点
     */
    @Override
    public PermissionComponent getParent() {
        return parent;
    }

    /**
     * 设置复合权限节点的父权限节点
     * @param parent 父权限节点
     */
    @Override
    public void setParent(PermissionComponent parent) {
        this.parent = parent;
    }

    /**
     * 获取复合权限节点的原始权限实体
     * @return 权限实体
     */
    @Override
    public Permission getPermission() {
        return permission;
    }
    
    /**
     * 构建权限树结构
     * @param allPermissions 所有权限列表
     * @param parentId 父权限ID
     * @return 构建好的权限树
     */
    public static CompositePermission buildPermissionTree(List<Permission> allPermissions, Long parentId) {
        // 查找指定父ID的权限作为根节点
        Permission rootPermission = allPermissions.stream()
                .filter(p -> p.getId().equals(parentId))
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("找不到指定ID的权限: " + parentId));
        
        CompositePermission root = new CompositePermission(rootPermission);
        
        // 递归构建子树
        buildSubtree(root, allPermissions);
        
        return root;
    }
    
    /**
     * 递归构建子树
     * @param parent 父节点
     * @param allPermissions 所有权限列表
     */
    private static void buildSubtree(CompositePermission parent, List<Permission> allPermissions) {
        Long parentId = parent.getId();
        
        // 查找所有父ID为parentId的权限
        List<Permission> children = allPermissions.stream()
                .filter(p -> p.getParentId() != null && p.getParentId().equals(parentId))
                .toList();
        
        // 为每个子权限创建节点并添加到父节点中
        for (Permission childPermission : children) {
            // 判断是叶子节点还是复合节点
            boolean hasChildren = allPermissions.stream()
                    .anyMatch(p -> p.getParentId() != null && p.getParentId().equals(childPermission.getId()));
            
            if (hasChildren) {
                // 有子节点，创建复合节点
                CompositePermission childNode = new CompositePermission(childPermission);
                parent.add(childNode);
                // 递归构建子树
                buildSubtree(childNode, allPermissions);
            } else {
                // 没有子节点，创建叶子节点
                LeafPermission leafNode = new LeafPermission(childPermission);
                parent.add(leafNode);
            }
        }
    }
}